Analysis of strain/apical distances responses in LCO 214-like structures

This note book extrat the data from finished calculations, plot and output CSV table for further analysis.

# Change the profile name to the actual one below
%aiida import-test
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from aiida_castep.workflows.relax import CastepRelaxWorkChain
from aiida.orm import StructureData, KpointsData
import pandas as pd
import ase

sns.set()

export_group = Group.objects.get_or_create(label='cu-apical-response/exports')[0]

relax_calc_lco = load_node(uuid="6592ad74-905b-4f85-a2ff-22a7c4fdfa97")
lco214_struct = relax_calc_lco.outputs.output_structure

relax_calc_123 = load_node('ca19c369-7bb4-4444-a338-3c543d8059c0')
Y123_struct = relax_calc_123.outputs.output_structure
relax_calc_hg1223 = load_node('e7867711-50b5-400f-b4b8-809d914542d8')
hg1223_struct = relax_calc_hg1223.outputs.output_structure

sframe_uuids_hg1223 = \
{'-0.01': '873c99a5-3668-47b8-bf5d-7bba08fb7b45',
 '-0.02': '57a03a3d-36ae-4d26-9234-d3af574d61dd',
 '-0.03': '3708ff2f-3a84-4038-8315-8ec13925003c',
 '-0.04': 'b73b18dd-1e5d-470e-b048-5b3558b41d48',
 '0.0': 'c33e8f83-75ab-4d74-86eb-9b4bc1ce46f6',
 '0.01': '9d7d4bbe-6c29-4234-b569-41386f19e796',
 '0.02': '389b020e-23bc-4ed1-9ed6-c055758682dc',
 '0.03': '1cb04b38-df05-4229-8b18-25cad202154e',
 '0.04': '1d9bf505-485c-45bd-ae29-83b46fa605d2'}

sframe_uuids_y123 = \
{'-0.01': 'f798a3f3-e435-48b4-8046-ae9c95b5c548',
 '-0.02': '07ee70e2-a126-4f2f-962c-596d18d47eec',
 '-0.03': '5a5b47d9-ea4d-4fd4-a112-83101c4c3ee7',
 '-0.04': '53de5bfd-3fe3-4dca-b51c-d2c12ec01b4c',
 '0.0': 'b129ae2f-de8a-403a-acab-b2a59ad1413e',
 '0.01': '634a2ab9-47d6-4be6-b828-eb613b038da7',
 '0.02': '8b40c216-fec0-4f17-a130-665bf47a1e0d',
 '0.03': 'c2b28372-5ead-4730-b31d-b788fd50531c',
 '0.04': '6b62f540-6a9e-43e8-934a-9cdf2db31664'}

#sframe_uuids = {k: v.uuid for k, v in sframes.items()}

sframe_uuids_lco214 = {'-0.04': 'bae35133-9691-4f1d-a87a-92db988ef572',
 '-0.03': '89a14631-0569-428d-a531-a93c58afdc93',
 '-0.02': 'fdecf5a4-b95b-4487-9bb7-13420da2c486',
 '-0.01': 'fa75685d-e17b-4187-815b-6068fb4ad8e2',
 '0.01': '81d811f3-da08-46dd-af90-ab1189a15b01',
 '0.02': '783ecacd-8b67-4410-ae46-45e71544ba08',
 '0.03': '000e6215-2d37-4ef0-8c8e-ec422bd6f9b8',
 '0.04': '1eb51375-3d61-4df7-80e4-c722334b7a55',
 '0.0': '6eef4841-c65b-453f-adf6-c0e0418eb099'}

Plot results - under a strain along the c direction

The a and b directions are left to be fully optimised

LCO 214

strains = [-4, -3, -2, -1, 1, 2, 3, 4, 0]
uuids = [
    "b428b4c3-5591-4abe-9d75-582b4b128d2d",
    "54e68005-10aa-454e-b09d-07bde12d5cc3",
    "f55cd103-91d2-4a44-9988-7e1eb83fb7d8",
    "340469a5-81e1-460d-b441-de5da16d0c68",
    "f05166e0-c625-4354-bf79-f09302ea9f5d",
    "0f8bb315-9fa9-44be-badc-11577d8719ec",
    "d062db58-de5c-4b30-8f13-ba95fd2614d8",
    "1d951ead-65a0-409a-b919-8ea20bcdc27f",
    "bf050e64-22c7-46ff-839e-16b45676753a"
]
sortargs = np.argsort(strains)
strains = np.array(strains)[sortargs]
strains = strains / 100
uuids = np.array(uuids)[sortargs]

dist = lambda s: s.outputs.output_structure.get_ase().get_distance(5, 12)
eng = lambda s: s.outputs.output_parameters['enthalpy']
cellz = lambda s: s.outputs.output_structure.cell[2][2]

nodes = [load_node(u) for u in uuids]
engs = [eng(n) for n in nodes]
dists = [dist(n) for n in nodes]
cz = [cellz(n) for n in nodes]
df = pd.DataFrame(np.array([engs, dists, cz]).T, columns=["energy", "Cu-Oa", "c"])
plt.subplot(211)
plt.plot(cz, engs, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel("DFT Total energy")
plt.subplot(212)
plt.plot(cz, dists, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel(r"Cu-$\rm O_a$ distance")
#plt.savefig("figures/cu-oa-vs-c.svg")
df.to_csv("cu-o-vs-c.csv")

Y123

sframe_uuids_y123 = \
{'-0.01': 'f798a3f3-e435-48b4-8046-ae9c95b5c548',
 '-0.02': '07ee70e2-a126-4f2f-962c-596d18d47eec',
 '-0.03': '5a5b47d9-ea4d-4fd4-a112-83101c4c3ee7',
 '-0.04': '53de5bfd-3fe3-4dca-b51c-d2c12ec01b4c',
 '0.0': 'b129ae2f-de8a-403a-acab-b2a59ad1413e',
 '0.01': '634a2ab9-47d6-4be6-b828-eb613b038da7',
 '0.02': '8b40c216-fec0-4f17-a130-665bf47a1e0d',
 '0.03': 'c2b28372-5ead-4730-b31d-b788fd50531c',
 '0.04': '6b62f540-6a9e-43e8-934a-9cdf2db31664'}

def get_relaxed_structure_calc(uuid):
    q = QueryBuilder()
    q.append(StructureData, filters={'uuid': uuid})
    q.append(CastepRelaxWorkChain, tag='relax', filters={'attributes.exit_status': 0}, project=['uuid'])
    q.append(Dict, with_outgoing='relax', filters={'attributes.PARAM': {'!has_key': 'spin'}})

    q.append(StructureData, with_incoming='relax')
    return q.first()[0]

def get_relaxed_structure_calc_spin(uuid):
    q = QueryBuilder()
    q.append(StructureData, filters={'uuid': uuid})
    q.append(CastepRelaxWorkChain, tag='relax', filters={'attributes.exit_status': 0}, project=['uuid'])
    q.append(Dict, with_outgoing='relax', filters={'attributes.PARAM.spin': {'>': 0.0}})
    q.append(StructureData, with_incoming='relax')
    return q.one()[0]

strains = []
uuids = []
for s, uuid in sframe_uuids_y123.items():
    strains.append(float(s))
    uuids.append(get_relaxed_structure_calc_spin(uuid))
    
sortargs = np.argsort(strains)
strains = np.array(strains)[sortargs]
strains = strains / 100
uuids = np.array(uuids)[sortargs]

view(Y123_struct.get_ase())

dist = lambda s: s.outputs.output_structure.get_ase().get_distance(4, 6)
eng = lambda s: s.outputs.output_parameters['enthalpy']
cellz = lambda s: s.outputs.output_structure.cell[2][2]

nodes = [load_node(u) for u in uuids]
snodes = [n.outputs.output_structure for n in nodes]
engs = [eng(n) for n in nodes]
dists = [dist(n) for n in nodes]
cz = [cellz(n) for n in nodes]
df = pd.DataFrame(np.array([engs, dists, cz]).T, columns=["energy", "Cu-Oa", "c"])
plt.subplot(211)
plt.plot(cz, engs, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel("DFT Total energy")
plt.subplot(212)
plt.plot(cz, dists, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel(r"Cu-$\rm O_a$ distance")
#plt.savefig("figures/y123-cu-oa-vs-c-spin.svg")
df.to_csv("y123-cu-o-vs-c-spin.csv")

Hg1223

sframe_uuids_hg1223 = \
{'-0.01': '873c99a5-3668-47b8-bf5d-7bba08fb7b45',
 '-0.02': '57a03a3d-36ae-4d26-9234-d3af574d61dd',
 '-0.03': '3708ff2f-3a84-4038-8315-8ec13925003c',
 '-0.04': 'b73b18dd-1e5d-470e-b048-5b3558b41d48',
 '0.0': 'c33e8f83-75ab-4d74-86eb-9b4bc1ce46f6',
 '0.01': '9d7d4bbe-6c29-4234-b569-41386f19e796',
 '0.02': '389b020e-23bc-4ed1-9ed6-c055758682dc',
 '0.03': '1cb04b38-df05-4229-8b18-25cad202154e',
 '0.04': '1d9bf505-485c-45bd-ae29-83b46fa605d2'}


strains = []
uuids = []
for s, uuid in sframe_uuids_hg1223.items():
    strains.append(float(s))
    uuids.append(get_relaxed_structure_calc(uuid))

sortargs = np.argsort(strains)
strains = np.array(strains)[sortargs]
strains = strains / 100
uuids = np.array(uuids)[sortargs]

dist = lambda s: s.outputs.output_structure.get_ase().get_distance(14, 6)
eng = lambda s: s.outputs.output_parameters['enthalpy']
cellz = lambda s: s.outputs.output_structure.cell[2][2]

nodes = [load_node(u) for u in uuids]
snodes = [n.outputs.output_structure for n in nodes]
engs = [eng(n) for n in nodes]
dists = [dist(n) for n in nodes]
cz = [cellz(n) for n in nodes]
df = pd.DataFrame(np.array([engs, dists, cz]).T, columns=["energy", "Cu-Oa", "c"])
plt.subplot(211)
plt.plot(cz, engs, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel("DFT Total energy")
plt.subplot(212)
plt.plot(cz, dists, "-x")
plt.xlabel(r"c /$\rm \AA$")
plt.ylabel(r"Cu-$\rm O_a$ distance")
#plt.savefig("figures/hg1223-cu-oa-vs-c.svg")
df.to_csv("hg1223-cu-o-vs-c.csv")

Extracting results with both c and ab strained

CastepRelaxWorkChain = WorkflowFactory('castep.relax')
def strain1_query(entry_node, mesh=None):
    ## Acquire strain using AiiDA querying
    # Query two this query finds the relaxed structures that undergoes a strain applications
    q = QueryBuilder()
    q.append(Node, filters={'id': entry_node.pk})
    q.append(CalcFunctionNode, project=['attributes.function_name'], 
              filters={'attributes.function_name': {'like': '%strain%'}},
             tag='strain_calc1')
    q.append(Float, with_outgoing='strain_calc1', tag='strain1', project=['attributes.value'])
    q.append(StructureData, with_incoming='strain_calc1', tag='strain_calc_struc1')
        
    q.append(CastepRelaxWorkChain, tag='relax', with_incoming='strain_calc_struc1', filters={'attributes.exit_status': 0})
    if mesh:
        q.append(KpointsData, filters={'attributes.mesh.0': mesh[0]}, with_outgoing='relax')
    q.append(Dict, with_incoming='relax', project=['attributes.zero_K_energy'], tag='calc_result')
    q.append(StructureData, with_incoming='relax', tag='relax_struct', project=['*'])
    return q.dict()

def strain1_query_spin(entry_node, mesh=None):
    ## Acquire strain using AiiDA querying
    # Query two this query finds the relaxed structures that undergoes a strain applications
    q = QueryBuilder()
    q.append(Node, filters={'id': entry_node.pk})
    q.append(CalcFunctionNode, project=['attributes.function_name'], tag='strain_calc1',
             filters={'attributes.function_name': {'like': '%strain%'}},)
    q.append(Float, with_outgoing='strain_calc1', tag='strain1', project=['attributes.value'])
    q.append(StructureData, with_incoming='strain_calc1', tag='strain_calc_struc1')
    q.append(CastepRelaxWorkChain, tag='relax', with_incoming='strain_calc_struc1', filters={'attributes.exit_status': 0})
    q.append(Dict, with_incoming='relax', project=['attributes.zero_K_energy'], tag='calc_result')
    q.append(StructureData, with_incoming='relax', tag='relax_struct', project=['*'])
    q.append(Dict, with_outgoing='relax', filters={'attributes.PARAM.spin': {'>': 0.0}})

    return q.dict()

# Query two this query finds the relaxed structures that undergoes two strain applications
def strain2_query(entry_node, mesh=None):
    q = QueryBuilder()
    q.append(Node, filters={'id': entry_node.pk})
    q.append(CalcFunctionNode, filters={'attributes.function_name': {'like': '%strain%'}},
             project=['attributes.function_name'], tag='strain_calc1')
    q.append(Float, with_outgoing='strain_calc1', tag='strain1', project=['attributes.value'])
    q.append(StructureData, with_incoming='strain_calc1', tag='strain_struc1', project=['*'])
    q.append(CalcFunctionNode, project=['attributes.function_name'], tag='strain_calc2')
    q.append(Float, with_outgoing='strain_calc2', tag='strain2', project=['attributes.value'])
    q.append(StructureData, with_incoming='strain_calc2', tag='strain_calc_struc2', project=['*'])
    q.append(CastepRelaxWorkChain, tag='relax', with_incoming='strain_calc_struc2', filters={'attributes.exit_status': 0})
    if mesh:
        q.append(KpointsData, filters={'attributes.mesh.0': mesh[0]}, with_outgoing='relax')
    q.append(Dict, with_incoming='relax', project=['attributes.zero_K_energy'], tag='calc_result')
    q.append(StructureData, with_incoming='relax', tag='relax_struct', project=['*'])
    return q.dict()

dist = lambda s: s.outputs.output_structure.get_ase().get_distance(17, 32)
eng = lambda s: s.outputs.output_parameters['enthalpy']
cellz = lambda s: s.outputs.output_structure.cell[2][2]

def get_eng_of_relaxed(node):
    q = QueryBuilder()
    q.append(Node, filters={'id': node.id})
    q.append(CalcJobNode, with_outgoing=Node)
    q.append(Dict, edge_filters={'label': 'output_parameters'}, project=['attributes.zero_K_energy'])
    return q.one()[0]

import plotly.graph_objects as go

def plot_3d(df, column='energy'):
    df_eng = df.pivot(index='abstrain', columns='zstrain', values=column)
    fig = go.Figure(data=[go.Surface(z=df_eng.values, x=df_eng.columns, y=df_eng.index)])
    fig.update_traces(contours_z=dict(show=True, usecolormap=True,
                                      highlightcolor="limegreen", project_z=True))
    fig.update_layout(title=column, autosize=False,
                      scene_camera_eye=dict(x=1.87, y=0.88, z=-0.64),
                      width=500, height=500,
                      margin=dict(l=65, r=50, b=65, t=90)
    )

    return fig

Y123

res1 = strain1_query(Y123_struct)
res2 = strain2_query(Y123_struct)
entry_node = Y123_struct
abstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]
zstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]
struc_storage = {z: {} for z in zstrains}
eng_storage = {z: {} for z in zstrains}
records = [{
    'zstrain': 0.0,
    'abstrain': 0.0,
    'structure': Y123_struct,
    'energy': get_eng_of_relaxed(Y123_struct),
}]

stype = lambda x: 'ab' if x.endswith('_ab') else 'z'
stag = lambda x: x

# Populate the stroage space with the structure
# Immediate results
struc_storage[0.0][0.0] = entry_node
eng_storage[0.0][0.0] = entry_node.get_incoming().first().node.outputs.output_parameters['zero_K_energy']
for tmp in res1:
    abstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain1']['attributes.value'])
    zstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain1']['attributes.value'])
    struc_storage[zstrain][abstrain] = tmp['relax_struct']['*']
    eng_storage[zstrain][abstrain] = tmp['calc_result']['attributes.zero_K_energy']
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# After two applications
for tmp in res2:
    zstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain2']['attributes.value'])
    abstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain2']['attributes.value'])
    struc_storage[zstrain][abstrain] = tmp['relax_struct']['*']
    eng_storage[zstrain][abstrain] = tmp['calc_result']['attributes.zero_K_energy']
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# Cu and O indices
y123dist = lambda s: s.get_ase().get_distance(4, 6) if isinstance(s, StructureData) else None 
cellz = lambda s: s.cell[2][2] if isinstance(s, StructureData) else None
cella = lambda s: s.cell[0][0] if isinstance(s, StructureData) else None
cellb = lambda s: s.cell[1][1] if isinstance(s, StructureData) else None

df_all = pd.DataFrame.from_records(records)
df_all['c'] = df_all['structure'].apply(cellz)
df_all['a'] = df_all['structure'].apply(cella)
df_all['b'] = df_all['structure'].apply(cellb)

df_all['cuoa'] = df_all['structure'].apply(y123dist)
df_all_nodu = df_all.drop_duplicates(['abstrain', 'zstrain'])
df_all_nodu[['a', 'b', 'c', 'cuoa', 'energy', 'abstrain', 'zstrain']].to_csv('y123-all.csv')

plot_3d(df_all_nodu)

Hg1223

mesh = [8, 8, 2]
entry_node = hg1223_struct
res1 = strain1_query(hg1223_struct, mesh=mesh)
res2 = strain2_query(hg1223_struct, mesh=mesh)
abstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]
zstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]
struc_storage = {z: {} for z in zstrains}
eng_storage = {z: {} for z in zstrains}

stype = lambda x: 'ab' if x.endswith('_ab') else 'z'
stag = lambda x: x
records = [{
    'zstrain': 0.0,
    'abstrain': 0.0,
    'structure': hg1223_struct,
    'energy': get_eng_of_relaxed(hg1223_struct),
}]

# Populate the stroage space with the structure
# Immediate results
struc_storage[0.0][0.0] = hg1223_struct
eng_storage[0.0][0.0] = entry_node.get_incoming().first().node.outputs.output_parameters['zero_K_energy']
for tmp in res1:
    abstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain1']['attributes.value'])
    zstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain1']['attributes.value'])
    struc_storage[zstrain][abstrain] = tmp['relax_struct']['*']
    eng_storage[zstrain][abstrain] = tmp['calc_result']['attributes.zero_K_energy']
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# After two applications
for tmp in res2:
    zstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain2']['attributes.value'])
    abstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain2']['attributes.value'])
    struc_storage[zstrain][abstrain] = tmp['relax_struct']['*']
    eng_storage[zstrain][abstrain] = tmp['calc_result']['attributes.zero_K_energy']
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# Cu and O indices
hg1223d = lambda s: s.get_ase().get_distance(14, 6) if isinstance(s, StructureData) else None 

cellz = lambda s: s.cell[2][2] if isinstance(s, StructureData) else None
cella = lambda s: s.cell[0][0] if isinstance(s, StructureData) else None
cellb = lambda s: s.cell[1][1] if isinstance(s, StructureData) else None

df_all = pd.DataFrame.from_records(records)
df_all['c'] = df_all['structure'].apply(cellz)
df_all['a'] = df_all['structure'].apply(cella)
df_all['b'] = df_all['structure'].apply(cellb)

df_all['cuoa'] = df_all['structure'].apply(hg1223d)
df_all_nodu = df_all.drop_duplicates(['abstrain', 'zstrain'])
df_all_nodu[['a', 'b', 'c', 'cuoa', 'energy', 'abstrain', 'zstrain']].to_csv('hg1223-all.csv')

df_eng = df_all_nodu.pivot(index='abstrain', columns='zstrain', values='energy')

plot_3d(df_all_nodu, column='energy')

LCO 214

res1 = strain1_query(lco214_struct)
res2 = strain2_query(lco214_struct)

abstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]
zstrains = [-0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04]

stype = lambda x: 'ab' if x.endswith('_ab') else 'z'
stag = lambda x: x
records = [{
    'zstrain': 0.0,
    'abstrain': 0.0,
    'structure': lco214_struct,
    'energy': get_eng_of_relaxed(lco214_struct),
}]

# Populate the stroage space with the structure
struc_storage[0.0][0.0] = lco214_struct
for tmp in res1:
    abstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain1']['attributes.value'])
    zstrain = stag(0.0) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain1']['attributes.value'])
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# After two applications
for tmp in res2:
    zstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'z' else stag(tmp['strain2']['attributes.value'])
    abstrain = stag(tmp['strain1']['attributes.value']) if stype(tmp['strain_calc1']['attributes.function_name']) == 'ab' else stag(tmp['strain2']['attributes.value'])
    records.append({'zstrain': zstrain, 'abstrain': abstrain, 
                    'structure': tmp['relax_struct']['*'],
                    'energy': tmp['calc_result']['attributes.zero_K_energy']})
# Cu and O indices
lco214d = lambda s: s.get_ase().get_distance(5, 12) if isinstance(s, StructureData) else None 
cellz = lambda s: s.cell[2][2] if isinstance(s, StructureData) else None
cella = lambda s: s.cell[0][0] if isinstance(s, StructureData) else None
cellb = lambda s: s.cell[1][1] if isinstance(s, StructureData) else None

df_all = pd.DataFrame.from_records(records)
df_all['c'] = df_all['structure'].apply(cellz)
df_all['a'] = df_all['structure'].apply(cella)
df_all['b'] = df_all['structure'].apply(cellb)

df_all['cuoa'] = df_all['structure'].apply(lco214d)
df_all_nodu = df_all.drop_duplicates(['abstrain', 'zstrain'])
df_all_nodu[['a', 'b', 'c', 'cuoa', 'energy', 'abstrain', 'zstrain']].to_csv('lco214-all.csv')

plot_3d(df_all_nodu, column='energy')

plot_3d(df_all_nodu, column='cuoa')

# Visualise the structures
res = df_all_nodu.loc[df_all_nodu['zstrain'] == 0 , ['a', 'abstrain', 'structure', ]]
print(res)
view([n.get_ase() for n in res['structure']])

           a  abstrain                                          structure
0   3.821686      0.00  uuid: 6eef4841-c65b-453f-adf6-c0e0418eb099 (pk...
1   3.974554      0.04  uuid: 1bf3f761-0d00-4f91-8ce6-7170b5644c5b (pk...
6   3.859903      0.01  uuid: b4507003-5eb9-4494-89f3-06a8cf3fccf8 (pk...
13  3.668819     -0.04  uuid: b91b4205-72c1-433d-a578-612da72992b0 (pk...
18  3.898120      0.02  uuid: 684169cd-77af-4388-bf8f-77b9d3a61014 (pk...
21  3.745253     -0.02  uuid: a8c411de-4ad8-4437-98e8-022f0f97f28a (pk...
22  3.936337      0.03  uuid: 943d50f2-50ce-4f65-918e-f69fccbd5cf6 (pk...
23  3.783470     -0.01  uuid: cb484b2f-7cb7-41ff-b12a-22d8fe229326 (pk...
24  3.707036     -0.03  uuid: dc9f13d7-63c9-40f9-baac-588b78e8717d (pk...

<subprocess.Popen at 0x7fce08086220>